home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource5 / 355_01 / slk1.exe / SHERLOCK / SL.H < prev    next >
C/C++ Source or Header  |  1991-06-09  |  8KB  |  296 lines
  1. /*
  2.     Header file for Sherlock version 2 of the Sherlock macros.
  3.  
  4.     source:  sl.h
  5.     started: September 27, 1985
  6.     version:
  7.         1.1 February 16, 1989
  8.         1.5 August 3, 1989
  9.         1.6 April 17, 1990
  10.         1.7 June 15, 1991
  11.  
  12.  
  13.     PUBLIC DOMAIN SOFTWARE
  14.  
  15.     Sherlock, including the SPP, SDEL and SDIF programs, was placed in
  16.     the public domain on June 15, 1991, by its author,
  17.  
  18.         Edward K. Ream
  19.         166 North Prospect Ave.
  20.         Madison, WI 53705.
  21.         (608) 257-0802
  22.  
  23.     Sherlock may be used for any commercial or non-commercial purpose.
  24.  
  25.  
  26.     DISCLAIMER OF WARRANTIES
  27.  
  28.     Edward K. Ream (Ream) specifically disclaims all warranties,
  29.     expressed or implied, with respect to this computer software,
  30.     including but not limited to implied warranties of merchantability
  31.     and fitness for a particular purpose.  In no event shall Ream be
  32.     liable for any loss of profit or any commercial damage, including
  33.     but not limited to special, incidental consequential or other damages.
  34. */
  35.  
  36. #define SL_VERSION_NAME "1.6"
  37.  
  38. /*
  39.     NOTE 1:    You must include this file (or sl1.h) in every file that
  40.         contains any Sherlock macro.  This file, rather than sl1.h,
  41.         is the prefered file to include because the version 2 routines
  42.         run faster.
  43.         
  44.     NOTE 2:    If you want the sherlock macros to be enabled, you must
  45.         define the SHERLOCK symbol BEFORE including this file.
  46.  
  47.     NOTE 3:    This file uses functions prototypes from the new ANSI standard.
  48.         When older compilers, undefine HAS_ANSI_PROTOTYPES.
  49. */
  50.  
  51. #define HAS_ANSI_PROTOTYPES 1
  52.  
  53. /* Synonyms. */
  54.  
  55. #define LEAVE(a)        TICKX(a)
  56. #define ENTER(a)        TICKB(a)
  57. #define ENTER_TRACE(a,b)    TRACEPB(a,b)
  58.  
  59. /* Always define these. */
  60. #define SL_DISABLE()
  61. #define SL_ENABLE()
  62.  
  63. #ifdef SHERLOCK
  64.  
  65. /* Macros common to version 1 and version 2. */
  66.  
  67. #define SL_CLEAR()    sl_clear()
  68. #define SL_DUMP()    sl_dump()
  69. #define SL_INIT()    sl_init(SL_VERSION_NAME)
  70. #define SL_NAME(a,b)    static char a [] = b
  71. #define SL_OFF(s)    sl_off(s)
  72. #define SL_ON(s)    sl_on(s)
  73. #define SL_PARSE(argc,argv,on,off) sl_parse(&argc,argv,on,off)
  74.  
  75. /*
  76.     Note:    Routines that exit from a nesting level do NOT need a handle
  77.         parameter because the call_stack provides it.
  78. */
  79.  
  80. /* Make SURE that the expression is evaluated exactly once. */
  81.  
  82. #define RETURN_BOOL(a,b)    return sl_xb(a,b)
  83. #define RETURN_CHAR(a,c)    return sl_xc(a,c)
  84. #define RETURN_DOUBLE(a,d)    return sl_xd(a,d)
  85. /* Floats passed as doubles. */
  86. #define RETURN_FLOAT(a,f)    return sl_xd(a,f)
  87. #define RETURN_INT(a,i)        return sl_xi(a,(int)i)
  88. #define RETURN_LONG(a,l)    return sl_xl(a,l)
  89. #define RETURN_PTR(a,p)        return sl_xp(a,p)
  90. #define RETURN_STRING(a,s)    return sl_xs(a,s)
  91. #define RETURN_UINT(a,ui)    return sl_xui(a,ui)
  92. #define RETURN_ULONG(a,ul)    return sl_xul(a,ul)
  93. #define RETURN_VOID(a)        {sl_xv(a); return;}
  94.  
  95. #define STATX(a)        sl_xtrace(a);    /* Ignore the return code. */
  96. #define TICKX(a)        sl_x(a)
  97. #define TICKX_BOOL(a,b)        sl_xb(a,b)
  98. #define TICKX_CHAR(a,c)        sl_xc(a,c)
  99. #define TICKX_DOUBLE(a,d)    sl_xd(a,d)
  100. #define TICKX_FLOAT(a,f)    sl_xf(a,f)
  101. #define TICKX_INT(a,i)        sl_xi(a,i)
  102. #define TICKX_LONG(a,l)        sl_xl(a,l)
  103. #define TICKX_PTR(a,p)        sl_xp(a,p)
  104. #define TICKX_STRING(a,s)    sl_xs(a,s)
  105. #define TICKX_UINT(a,u)        sl_xui(a,u)
  106. #define TICKX_ULONG(a,u)    sl_xul(a,u)
  107. #define TICKX_VOID(a)        sl_xv(a)
  108. #define TRACEX(a,b)        if(sl_xtrace(a)) {b;}
  109. #define TRACEPX(a,b)        if(sl_pxtrace(a)) {b;}
  110.  
  111. /* Macros for routines which are unique to version 2. */
  112.  
  113. #define STAT(a)        {static void *h=0; sl2stat(&h,a);}
  114. #define STATB(a)    {static void *h=0; sl2bstat(&h,a);}
  115.  
  116. #define TICK(a)        {static void *h=0; sl2tick(&h,a);}
  117. #define TICKB(a)    {static void *h=0; sl2btick(&h,a);}
  118. #define TICKN(a)    {static void *h=0; sl2ntick(&h,a);}
  119.  
  120. #define TRACE(a,b)    {static void *h=0; if(sl2trace(&h,a)) {b;}}
  121. #define TRACEB(a,b)    {static void *h=0; if(sl2btrace(&h,a)) {b;}}
  122. #define TRACEN(a,b)    {static void *h=0; if(sl2ntrace(&h,a)) {b;}}
  123.  
  124. #define TRACEP(a,b)    {static void *h=0; if(sl2ptrace(&h,a)) {b;}}
  125. #define TRACEPB(a,b)    {static void *h=0; if(sl2pbtrace(&h,a)) {b;}}
  126. #define TRACEPN(a,b)    {static void *h=0; if(sl2pntrace(&h,a)) {b;}}
  127.  
  128. /*
  129.     Function prototypes.
  130. */
  131. #ifdef HAS_ANSI_PROTOTYPES
  132.  
  133. /* Routines common to Version 1 and Version 2. */
  134.  
  135. void    sl_dump        (void);
  136. void    sl_init        (char *);
  137. void    sl_off        (char *);
  138. void    sl_on        (char *);
  139. void    sl_parse    (int *,char **,char *,char *);
  140. int    sl_pxtrace    (char *);        /* TRACEPX */
  141. void    sl_x        (char *);        /* TICKX */
  142. int    sl_xb        (char *,int);
  143. char    sl_xc        (char *,char);
  144. double    sl_xd        (char *,double);
  145. double    sl_xf        (char *,double);
  146. int    sl_xi        (char *,int);
  147. long    sl_xl        (char *,long);
  148. void *    sl_xp        (char *,void *);
  149. char *    sl_xs        (char *,char *);
  150. int    sl_xtrace    (char *);        /* TRACEX */
  151. unsigned int  sl_xui    (char *,unsigned int);
  152. unsigned long sl_xul    (char *,unsigned long);
  153. void    sl_xv        (char *);
  154.  
  155. void    sl_bout    (int);
  156. void    sl_cout    (char);
  157. void    sl_dout    (double);
  158. void    sl_fout    (double);    /* Floats are passed as doubles. */
  159. void    sl_iout    (int);
  160. void    sl_lout    (long);
  161. void    sl_pout (void *);
  162. char *    sl_sbout(int);
  163. void    sl_sout (char *);
  164. void    sl_uiout(unsigned int);
  165. void    sl_ulout(unsigned long);
  166.  
  167. void    sl_csout(void);
  168. void    sl_lpout(void);
  169. void    sl_rpout(void);
  170.  
  171. /* Version 2 routines. */
  172.  
  173. void    sl2bstat    (void *,char *);
  174. void    sl2btick    (void *,char *);
  175. int    sl2btrace    (void *,char *);
  176. void    sl2ntick    (void *,char *);
  177. int    sl2ntrace    (void *,char *);
  178. int    sl2pbtrace    (void *,char *);
  179. int    sl2pntrace    (void *,char *);
  180. int    sl2ptrace    (void *,char *);
  181. void    sl2stat        (void *,char *);
  182. void    sl2tick        (void *,char *);
  183. int    sl2trace    (void *,char *);
  184.  
  185. #else
  186.  
  187. void    sl_dump();
  188. void    sl_init();
  189. void    sl_off();
  190. void    sl_on();
  191. void    sl_parse();
  192. int    sl_pxtrace();    /* TRACEPX */
  193. void    sl_x();        /* TICKX */
  194. int    sl_xb();
  195. char    sl_xc();
  196. double    sl_xd();
  197. double    sl_xf();
  198. int    sl_xi();
  199. long    sl_xl();
  200. void *    sl_xp();
  201. char *    sl_xs();
  202. int    sl_xtrace();    /* TRACEX */
  203. unsigned int  sl_xui();
  204. unsigned long sl_xul();
  205. void    sl_xv();
  206.  
  207. void    sl_bout();
  208. void    sl_cout();
  209. void    sl_csout();
  210. void    sl_dout();
  211. void    sl_fout();
  212. void    sl_iout();
  213. void    sl_lout();
  214. void    sl_pout();
  215. char *    sl_sbout();
  216. void    sl_sout();
  217. void    sl_uiout();
  218. void    sl_ulout();
  219.  
  220. void    sl_csout();
  221. void    sl_lpout();
  222. void    sl_rpout();
  223.  
  224. void    sl2bstat();
  225. void    sl2btick();
  226. int    sl2btrace();
  227. void    sl2ntick();
  228. int    sl2ntrace();
  229. int    sl2pbtrace();
  230. int    sl2pntrace();
  231. int    sl2ptrace();
  232. void    sl2stat();
  233. void    sl2tick();
  234. int    sl2trace();
  235.  
  236. #endif /* HAS_ANSI_PROTOTYPES */
  237.  
  238. #else
  239.  
  240. /*
  241.     Null macro definitions for all Sherlock macros.
  242. */
  243.  
  244. #define RETURN_BOOL(a,b)    return b
  245. #define RETURN_CHAR(a,c)    return c
  246. #define RETURN_DOUBLE(a,d)    return d
  247. #define RETURN_FLOAT(a,f)    return f
  248. #define RETURN_INT(a,i)        return i
  249. #define RETURN_LONG(a,l)    return l
  250. #define RETURN_PTR(a,p)        return p
  251. #define RETURN_STRING(a,s)    return s
  252. #define RETURN_UINT(a,u)    return u
  253. #define RETURN_ULONG(a,u)    return u
  254. #define RETURN_VOID(a)        return
  255.  
  256. #define SL_CLEAR()
  257. #define SL_DUMP()
  258. #define SL_INIT()
  259. #define SL_NAME(a,b)
  260. #define SL_OFF(s)
  261. #define SL_ON(s)
  262. #define SL_PARSE(argc,argv,on,off)
  263.  
  264. #define STAT(a)
  265. #define STATB(a)
  266. #define STATX(a)
  267.  
  268. #define TICK(a)
  269. #define TICKB(a)
  270. #define TICKN(a)
  271.  
  272. #define TICKX(a)
  273. #define TICKX_BOOL(a,b)
  274. #define TICKX_CHAR(a,c)
  275. #define TICKX_DOUBLE(a,d)
  276. #define TICKX_FLOAT(a,f)
  277. #define TICKX_INT(a,i)
  278. #define TICKX_LONG(a,l)
  279. #define TICKX_PTR(a,p)
  280. #define TICKX_STRING(a,s)
  281. #define TICKX_UINT(a,u)
  282. #define TICKX_ULONG(a,u)
  283. #define TICKX_VOID(a)
  284.  
  285. #define TRACE(a,b)
  286. #define TRACEB(a,b)
  287. #define TRACEN(a,b)
  288. #define TRACEX(a,b)
  289.  
  290. #define TRACEP(a,b)
  291. #define TRACEPB(a,b)
  292. #define TRACEPN(a,b)
  293. #define TRACEPX(a,b)
  294.  
  295. #endif /* ifdef SHERLOCK */
  296.